package com.company.project.utils;

import com.company.project.model.User;
import org.springframework.util.StringUtils;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
import java.util.*;

/**
 * @Author: chenyang
 * @Description: session 存储分为2种： 1：redis  2:内存中
 *  如果存内存中 每次重启都需要进行登陆
 * @Date: Created in 14:30 2017/5/15.
 * @Modifyed By:
 */

//@WebListener
public class SessionListener implements HttpSessionListener {

    // key为sessionId，value为HttpSession，使用static，定义静态变量，使之程序运行时，一直存在内存中。
    private static Map<String, HttpSession> sessionMap = new HashMap<String, HttpSession>(500);
    public static String SESSION_TIMEOUT=3600+"";

    /**
     * HttpSessionListener中的方法，在创建session
     */
    @Override
    public void sessionCreated(HttpSessionEvent event) {
        // TODO Auto-generated method stub
    }

    /**
     * HttpSessionListener中的方法，回收session时,删除sessionMap中对应的session
     */
    @Override
    public void sessionDestroyed(HttpSessionEvent event) {
        getSessionMap().remove(event.getSession().getId());
    }

    /**
     * 得到在线用户会话集合
     */
    public static List<HttpSession> getUserSessions() {
        List<HttpSession> list = new ArrayList<HttpSession>();
        Iterator<String> iterator = getSessionMapKeySetIt();
        while (iterator.hasNext()) {
            String key = iterator.next();
            HttpSession session = getSessionMap().get(key);
            list.add(session);
        }
        return list;
    }

    /**
     * 得到用户对应会话map，key为用户ID,value为会话ID
     */
    public static Map<String, String> getUserSessionMap() {
        Map<String, String> map = new HashMap<String, String>();
        Iterator<String> iter = getSessionMapKeySetIt();
        while (iter.hasNext()) {
            String sessionId = iter.next();
            HttpSession session = getSessionMap().get(sessionId);
            User user = (User) session.getAttribute("LOCAL_CLINET_USER");
            if (user != null) {
//                map.put(user.getUser_id(), sessionId);
            }
        }
        return map;
    }

    private static Map<String, String> getHeadersInfo(HttpServletRequest request) {
        Map<String, String> map = new HashMap<String, String>();
        Enumeration headerNames = request.getHeaderNames();
        while (headerNames.hasMoreElements()) {
            String key = (String) headerNames.nextElement();
            String value = request.getHeader(key);
            map.put(key, value);
        }
        return map;
    }

    public static User sessionUserInfo(){
        HttpServletRequest req=ContextHolderUtils.getRequest();
        String sessionId=req.getHeader("token");
        if(StringUtils.isEmpty(sessionId))
        {
            sessionId=req.getParameter("token");
        }
        User sessionuser=null;
        HttpSession session = getSessionMap().get(sessionId);
            if(session!=null)
            {
                try {
                    Object session_user = session.getAttribute("LOCAL_CLINET_USER");
                    String cr_time=session.getAttribute("CR_TIME").toString();
                    String now_time=CommonUtils.GetNowtime();
                    String cha=CommonUtils.countTime(cr_time,now_time);
                    if(Integer.parseInt(cha)>Integer.parseInt(SESSION_TIMEOUT))
                    {
                        session_user=null;
                    }
                    else{
                        session.setAttribute("CR_TIME",now_time);
                    }
                    if (session_user != null) {
                        sessionuser = (User) session_user;  // 这是你设置 保存用户对应session名
                    }
                    else{
                        removeSession(sessionId);
                    }
                }
                catch(Exception e){
                    removeSession(sessionId);
                }
            }
            else{
                removeSession(sessionId);
            }

//        }
        return sessionuser;
    }

    /**
     * 移除用户Session
     */
    public synchronized static void removeUserSession(String userId) {
        Map<String, String> userSessionMap = getUserSessionMap();
        if (userSessionMap.containsKey(userId)) {
            String sessionId = userSessionMap.get(userId);
            getSessionMap().get(sessionId).invalidate();
            getSessionMap().remove(sessionId);
        }
    }

    /**
     * 增加用户到session集合中
     */
    public static void addUserSession(HttpSession session) {
        getSessionMap().put(session.getId(), session);
    }

    /**
     * 移除一个session
     */
    public static void removeSession(String sessionID) {
        if(getSessionMap().get(sessionID)!=null) {
            getSessionMap().get(sessionID).invalidate();
        }
        getSessionMap().remove(sessionID);
    }

    public static boolean containsKey(String key) {
        return getSessionMap().containsKey(key);
    }

    /**
     * 判断该用户是否已重复登录，使用
     * 同步方法，只允许一个线程进入，才好验证是否重复登录
     * @param user
     * @return
     */
    public synchronized static boolean checkIfHasLogin(User user) {
        Iterator<String> iter = getSessionMapKeySetIt();
        while (iter.hasNext()) {
            String sessionId = iter.next();
            HttpSession session = getSessionMap().get(sessionId);
            if(session!=null)
            {
                try {
                    Object session_user = session.getAttribute("LOCAL_CLINET_USER");
                    if (session_user != null) {
                        User sessionuser = (User) session_user;  // 这是你设置 保存用户对应session名
                        if (sessionuser != null) {
                            if (sessionuser.getUid().equals(user.getUid())) {

                                String cr_time=session.getAttribute("CR_TIME").toString();//创建时间,如果一直有后台访问,则会一直更新CR_TIME
                                String now_time=CommonUtils.GetNowtime();//当前时间
                                String cha=CommonUtils.countTime(cr_time,now_time);//计算当前时间与创建时间的差,如果大于设定的超时时间则可以登录
                                if(Integer.parseInt(cha)>Integer.parseInt(SESSION_TIMEOUT))
                                {
                                    removeSession(sessionId);
                                   return false;
                                }
                                return true;
                            }
                        }
                    }
                }
                catch(Exception e){
                    removeSession(sessionId);
                    return false;
                }
            }

        }
        return false;
    }

    /**
     * 获取在线的sessionMap
     */
    public static Map<String, HttpSession> getSessionMap() {
        return sessionMap;
    }

    /**
     * 获取在线sessionMap中的SessionId
     */
    public static Iterator<String> getSessionMapKeySetIt() {
        return getSessionMap().keySet().iterator();
    }


}

